package com.xzzz.irda.guardcat.core.metric.tomcat;

/**
 * Tomcat 线程池信息
 *
 * @author xzzz
 * @since 1.0.0
 */
public class TomcatThreadPoolInfo {

    /**
     * Tomcat 端口号
     */
    private Integer port;

    /**
     * 线程池领域
     */
    private String domain;

    /**
     * 线程池名字
     */
    private String name;

    /**
     * 同一时间服务器接受并处理的最大连接数。
     */
    private Integer maxConnections;

    /**
     * 当前连接数
     */
    private Long connectionCount;

    /**
     * 最大请求队列长度
     */
    private Integer acceptCount;

    /**
     * 连接器在接受连接后将等待呈现请求 URI 行的毫秒数。
     *      默认值为 60000（即 60 秒）。通常情况下设置为30000 或 20000。
     */
    private Integer connectionTimeout;




    /**
     * 最大请求处理线程数
     *      默认值 200 。
     */
    private Integer maxThreads;

    /**
     * 最小备用请求处理线程数【核心线程数】  默认值 10 。
     */
    private Integer minSpareThreads;

    /**
     * 当前线程数
     *      底层取的：PoolSize
     */
    private Integer currentThreadCount;

    /**
     * 繁忙线程数
     *      底层取的：ActiveCount
     */
    private Integer currentThreadsBusy;

    /**
     * 【标准 http 属性】HTTP 请求最大长连接个数
     *      建议此值为 maxThreads * 0.5 ，不得大于maxThreads，否则将得不到预期的效果。
     *          如果没有指定，该属性被设置为 100。
     */
    private Integer maxKeepAliveRequests;

    /**
     * 长链接数量
     */
    private Integer keepAliveCount;

    /**
     * 连接器在关闭连接之前将等待另一个 HTTP 请求的毫秒数。
     *      使用值 -1 表示没有超时（即无限）。
     *      如果此 tomcat 设计为“长链接”服务，可以适当增加 keepAliveTimeout 值，否则无需设置此值。
     *
     *   通常在 tomcat 上层还有 nginx 等代理服务器，通常希望链接 keepAlive 的机制由代理服务器控制，
     *      比如 nginx 来决定链接是否需要“保持活性”（注意，与 keep_alive 不同），
     *      当然 nginx 服务器只会保留极少的长连接，几乎所有的链接都会在使用结束后主动 close；
     *      因为链接复用层，将有 nginx 与 client 保持，而不再是 tomcat 与 client 保持。
     *      太多的 keepAlive 链接，尽管提高了链接使用效率，但是对负载均衡不利。
     */
    private Integer keepAliveTimeout;

    /**
     * 轮询器的 select() 超时时间（以毫秒为单位）。
     *      这个值很重要，因为连接清理是在同一个线程上完成的，所以不要将此值设置为非常高的值。默认值为 1000 毫秒。
     *
     *      selectorPool.maxSelectors：
     *             NIO 中选择的个数，默认值为 200。
     *             NIO 中我们可以使用多个 selector，每个 selector 负责注册一定数量的 NIOChannel，
     *             这样可以有效的提高 selector 选择效率；
     *             通常我们建议此值与 maxThreads 值一致，或者小于 maxThreads，但是大于 maxThreads 其实意义并不大。
     */
    private Long selectorTimeout;

    /**
     * 【标准 http 属性】使用 TCP 的 noDelay 功能
     *      如果为 true，服务器 socket 会设置 TCP_NO_DELAY 选项，在大多数情况下可以提高性能。
     *      缺省情况下设为 true。
     */
    private Boolean tcpNoDelay;

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public String getDomain() {
        return domain;
    }

    public void setDomain(String domain) {
        this.domain = domain;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getMaxConnections() {
        return maxConnections;
    }

    public void setMaxConnections(Integer maxConnections) {
        this.maxConnections = maxConnections;
    }

    public Long getConnectionCount() {
        return connectionCount;
    }

    public void setConnectionCount(Long connectionCount) {
        this.connectionCount = connectionCount;
    }

    public Integer getAcceptCount() {
        return acceptCount;
    }

    public void setAcceptCount(Integer acceptCount) {
        this.acceptCount = acceptCount;
    }

    public Integer getConnectionTimeout() {
        return connectionTimeout;
    }

    public void setConnectionTimeout(Integer connectionTimeout) {
        this.connectionTimeout = connectionTimeout;
    }

    public Integer getMaxThreads() {
        return maxThreads;
    }

    public void setMaxThreads(Integer maxThreads) {
        this.maxThreads = maxThreads;
    }

    public Integer getMinSpareThreads() {
        return minSpareThreads;
    }

    public void setMinSpareThreads(Integer minSpareThreads) {
        this.minSpareThreads = minSpareThreads;
    }

    public Integer getCurrentThreadCount() {
        return currentThreadCount;
    }

    public void setCurrentThreadCount(Integer currentThreadCount) {
        this.currentThreadCount = currentThreadCount;
    }

    public Integer getCurrentThreadsBusy() {
        return currentThreadsBusy;
    }

    public void setCurrentThreadsBusy(Integer currentThreadsBusy) {
        this.currentThreadsBusy = currentThreadsBusy;
    }

    public Integer getMaxKeepAliveRequests() {
        return maxKeepAliveRequests;
    }

    public void setMaxKeepAliveRequests(Integer maxKeepAliveRequests) {
        this.maxKeepAliveRequests = maxKeepAliveRequests;
    }

    public Integer getKeepAliveCount() {
        return keepAliveCount;
    }

    public void setKeepAliveCount(Integer keepAliveCount) {
        this.keepAliveCount = keepAliveCount;
    }

    public Integer getKeepAliveTimeout() {
        return keepAliveTimeout;
    }

    public void setKeepAliveTimeout(Integer keepAliveTimeout) {
        this.keepAliveTimeout = keepAliveTimeout;
    }

    public Long getSelectorTimeout() {
        return selectorTimeout;
    }

    public void setSelectorTimeout(Long selectorTimeout) {
        this.selectorTimeout = selectorTimeout;
    }

    public Boolean getTcpNoDelay() {
        return tcpNoDelay;
    }

    public void setTcpNoDelay(Boolean tcpNoDelay) {
        this.tcpNoDelay = tcpNoDelay;
    }

    @Override
    public String toString() {
        return "TomcatThreadPoolInfo{" +
                "port=" + port +
                ", domain='" + domain + '\'' +
                ", name='" + name + '\'' +
                ", maxConnections=" + maxConnections +
                ", connectionCount=" + connectionCount +
                ", acceptCount=" + acceptCount +
                ", connectionTimeout=" + connectionTimeout +
                ", maxThreads=" + maxThreads +
                ", minSpareThreads=" + minSpareThreads +
                ", currentThreadCount=" + currentThreadCount +
                ", currentThreadsBusy=" + currentThreadsBusy +
                ", maxKeepAliveRequests=" + maxKeepAliveRequests +
                ", keepAliveCount=" + keepAliveCount +
                ", keepAliveTimeout=" + keepAliveTimeout +
                ", selectorTimeout=" + selectorTimeout +
                ", tcpNoDelay=" + tcpNoDelay +
                '}';
    }
}
